package org.ccay.enumerable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.ccay.enumerable.loader.EnumLoader;

/**
 * 枚举信息获取类：可获取数据字典信息（包括xml，java可枚举类，数据库）
 * @author chaowangbang
 *
 */
public class DefaultEnumHelp implements Enum,EnumRefreshable {

	private EnumLoader enumLoader;
	
	public void setEnumLoader(EnumLoader enumLoader) {
		this.enumLoader = enumLoader;
	}

	private Map<String,List<EnumItem>> enumContainer;
	

	public void load(){
		//懒加载，清空enumContainer
		enumContainer = null;
	}

	@Override
	public List<EnumItem> getByType(String type) {
		return getEnumContainer().get(type);
	}

	@Override
	public EnumItem getByTypeName(String type, String name) {
		for(EnumItem item : getEnumContainer().get(type)){
			if(name.equals(item.getName())){
				return item;
			}
		}
		return null;
	}

	@Override
	public EnumItem getByTypeValue(String type, String value) {
		for(EnumItem item : getEnumContainer().get(type)){
			if(value.equals(item.getValue())){
				return item;
			}
		}
		return null;
	}

	@Override
	public EnumItem getByTypeIndex(String type, int index) {
		return getEnumContainer().get(type).get(index);
	}

	@Override
	public void refresh() {
		//懒加载，清空enumContainer
		enumContainer = null;
		getEnumContainer();
	}

	
	 /**
     * 获取枚举类数据(枚举类)
     * @param strType
     * @return
     */
    public List<EnumItem> getJavaEnumList(String strType){
    	List<EnumItem> enumList = new ArrayList<EnumItem>();
    	List<EnumItem> list = getByType(strType);
    	for (EnumItem enumItem : list) {
			if(enumItem.getClass().isEnum()){
				enumList.add(enumItem);
			}
		}
    	return enumList;
    }
    
    /**
     * 获取非枚举类数据(xml,db)
     * @param strType
     * @return
     */
    public List<EnumItem> getExtEnumList(String strType){
    	List<EnumItem> extEnumList = new ArrayList<EnumItem>();
    	List<EnumItem> list = getByType(strType);
    	for (EnumItem enumItem : list) {
			if(!enumItem.getClass().isEnum()){
				extEnumList.add(enumItem);
			}
		}
    	return extEnumList;
    }

	@Override
	public List<EnumItem> getAll() {
		List<EnumItem> all = new LinkedList<EnumItem>();
		for(Map.Entry<String, List<EnumItem>> entry : getEnumContainer().entrySet()){
			all.addAll(entry.getValue());
		}
		Collections.sort(all,new Comparator<EnumItem>(){
			@Override
			public int compare(EnumItem o1, EnumItem o2) {
				if(!o1.getType().equals(o2.getType())){
					return o1.getType().compareTo(o2.getType());
				}
				return o1.getIndex() - o2.getIndex();
			}
		});
		return all;
	}

	public Map<String, List<EnumItem>> getEnumContainer() {
		if(enumContainer == null){
			enumContainer = new ConcurrentHashMap<String,List<EnumItem>>();
			enumContainer.putAll(enumLoader.load());
		}
		return enumContainer;
	}
}
